#!/bin/sh
exitcode=0
trap 'rm -f $tmpfile $tmpfile2 $tmpfile3 $awkfile; exit $exitcode' 0 1 2 3 15

# Apache configuration script, first cut --- rst.
# Don't like it?  Inspired to do something better?  Go for it.

# second cut --- jmj
# At this point we change what Configuration contains. It maintain
# contains comments, specific compiler flags, a list of included
# modules and "rules". These rules are used to allow Configure to
# be totally configured from Configuration.
#
# Uses 4 supplemental scripts located in ./helpers:
#	CutRule: Determines the value for a specified Rule
#	GuessOS: Uses uname to determine OS/platform
#	PrintPath: generic "type" or "whence" replacement
#	TestCompile: Can check for libs and if $(CC) is ANSI
#	 (i.e., a simple "sanity check")
#
####################################################################
## Set up some defaults
##
file=Configuration
tmpfile=htconf.$$
tmpfile2=$tmpfile.2
tmpfile3=$tmpfile.3
awkfile=$tmpfile.4
SUBDIRS='$(OSDIR) main modules'

####################################################################
## Now handle any arguments, which, for now, is -file
## to select an alternate Configuration file
##
while [ "x$1" != "x" ]; do
  if [ "x$1" = "x-file" ] ; then
    shift 1; file=$1; shift 1
    if [ ! -r $file ]; then
      echo "$file does not exist or is not readable."
      exitcode=1
      exit 1
    fi
  else
    echo "Ignoring command line option '$1'"
    shift 1
  fi
done
echo "Using config file: $file"

if [ ! -r $file ]; then
  echo "Can't see or read \"$file\""
  exitcode=1
  exit 1
fi

####################################################################
## From the Configuration file, create a "cleaned-up" version
## that's easy to scan
##
#
# Strip comments and blank lines, remove whitespace around
# "=" assignments, change Rules to comments and then remove whitespace
# before Module declarations
#
sed 's/#.*//' $file | \
 sed '/^[ 	]*$/d' | \
 sed 's/[ 	]*$//' | \
 sed 's/[ 	]*=[ 	]*/=/' | \
 sed 's/^Rule[ 	]*/##Rule:/' | \
 sed 's/^[ 	]*AddModule/AddModule/' | \
 sed 's/^[        ]*%AddModule/%AddModule/' | \
 sed 's/^[ 	]*Module/Module/' | \
 sed 's/^[        ]*%Module/%Module/' > $tmpfile

#
# Only "assignment" ("=") statements and Module lines
# should be left at this point. If there is other stuff
# we bail out
#
if egrep -v '^%?Module[ 	]+[A-Za-z0-9_]+[ 	]+[^ 	]+$' $tmpfile \
 | egrep -v '^%?AddModule[ 	]+[^ 	]+$' \
 | grep -v = > /dev/null
then
  echo "Syntax error --- The configuration file is used only to"
  echo "define the list of included modules or to set Makefile"
  echo "options or Configure rules, and I don't see that at all:"
  egrep -v '^%?Module[ 	]+[A-Za-z0-9_]+[ 	]+[^ 	]+$' $tmpfile \
   | egrep -v '^%?AddModule[ 	]+[^ 	]+$'  \
   | grep -v =
  exitcode=1
  exit 1
fi

#
# File is OK --- make backup copies of things and then get the new ones:
#
if [ -f Makefile ] ; then mv Makefile Makefile.bak; fi
if [ -f modules.c ] ; then mv modules.c modules.c.bak; fi

####################################################################
# Start creating the Makefile. We add some comments and
# then fold in the modules that were included in Configuration
#
echo "Creating Makefile"
echo "#" > Makefile
echo "# Makefile automatically generated from Makefile.tmpl" >> Makefile
echo "# and configuration file by Apache config script." >> Makefile
echo "# Hand-edited changes will be lost if the config script" >> Makefile
echo "# is re-run" >> Makefile
echo "#" >> Makefile

####################################################################
# Now we create a stub file, called Makefile.config, which
# just includes those assignments (eg: CC=gcc) in Configuration
#
awk >Makefile.config <$tmpfile '
    BEGIN {
	print "# Makefile options inherited from Configure"
	print "###############"
    } 
    /\=/ { print } 
    END {
	print "###############"
    }'

####################################################################
# Extract the rules.
#
RULE_WANTHSREGEX=`./helpers/CutRule WANTHSREGEX $file`
RULE_STATUS=`./helpers/CutRule STATUS $file`
RULE_SOCKS4=`./helpers/CutRule SOCKS4 $file`
RULE_IRIXNIS=`./helpers/CutRule IRIXNIS $file`
RULE_IRIXN32=`./helpers/CutRule IRIXN32 $file`
RULE_PARANOID=`./helpers/CutRule PARANOID $file`

####################################################################
# Preset some "constants"; can be overridden on a per-platform basis below.
#
DBM_LIB="-ldbm"
DB_LIB="-ldb"
SHELL="/bin/sh"
if ./helpers/PrintPath -s ranlib; then
    RANLIB="ranlib"
else
    RANLIB="true"
fi

####################################################################
# Now we determine the OS/Platform automagically, thanks to
# GuessOS, a home-brewed OS-determiner ala config.guess
#
# We adjust CFLAGS, LIBS, LDFLAGS and INCLUDES (and other Makefile
# options) as required. Setting CC and OPTIM here has no effect
# if they were set in Configure.
#
# Also, we set DEF_WANTHSREGEX and to the appropriate
# value for each platform.
#
# As more PLATFORMs are added to Configuration.tmpl, be sure to
# add the required lines below.
#

PLAT=`./helpers/GuessOS`

SHELL="/bin/sh"
OSDIR="os/unix"

case "$PLAT" in
    *mint)
        OS="MiNT"
        CFLAGS="-DMINT"
        LIBS="$LIBS -lportlib -lsocket"
        DEF_WANTHSREGEX=yes
        ;;
    *MPE/iX*)
        OS='MPE/iX'
	CFLAGS="$CFLAGS -DMPE -D_POSIX_SOURCE -D_SOCKET_SOURCE"
	LIBS="$LIBS -lsocket"
	LDFLAGS="$LDFLAGS -Xlinker \"-WL,cap=ia,ba,ph,pm;nmstack=1024000\""
	;;
    *-apple-aux3*)
	OS='A/UX 3.1.x'
	CFLAGS="$CFLAGS -DAUX -D_POSIX_SOURCE"
	LIBS="$LIBS -lposix -lbsd"
	LDFLAGS="$LDFLAGS -s"
	DEF_WANTHSREGEX=no
	;;
    i386-ibm-aix*)
    	OS='IBM AIX PS/2'
	CFLAGS="$CFLAGS -DAIX -U__STR__ -DUSEBCOPY"
	DEF_WANTHSREGEX=no
	;;
    *-ibm-aix[1-3].*|*-ibm-aix4.[0-1])
        OS='IBM AIX < v4.2'
        CFLAGS="$CFLAGS -DAIX -DNEED_RLIM_T -U__STR__"
        ;;
    *-ibm-aix*)
        OS='IBM AIX >= 4.2'
        CFLAGS="$CFLAGS -DAIX -U__STR__"
	LDFLAGS="$LDFLAGS -lm"
        ;;
    *-apollo-*)
	OS='Apollo Domain'
	CFLAGS="$CFLAGS -DAPOLLO"
	;;
    *-dg-dgux*)
	OS='DG/UX 5.4'
	CFLAGS="$CFLAGS -DDGUX"
	DEF_WANTHSREGEX=yes
	;;
    *OS/2*)
	OSDIR="os/emx"
	DEF_WANTHSREGEX=yes
	OS='EMX OS/2'
	CFLAGS="$CFLAGS -Zbsd-signals -Zbin-files -DTCPIPV4 -g"
	LIBS="$LIBS -lsocket -llibufc -lbsd"
	DBM_LIB="-lgdbm"
	;;
    *-hi-hiux)
	OS='HI-UX'
	CFLAGS="$CFLAGS -DHIUX"
	;;
    *-hp-hpux10.*)
	OS='HP-UX 10'
	CFLAGS="$CFLAGS -DHPUX10"
	;;
    *-hp-hpux*)
	OS='HP-UX'
	CFLAGS="$CFLAGS -DHPUX"
	;;
    *-sgi-irix64)
# Note: We'd like to see patches to compile 64-bit, but for now...
	echo "You are running 64-bit Irix. For now, we will compile 32-bit"
	echo "but if you would care to port to 64-bit, send us the patches."
	CFLAGS="$CFLAGS -n32"
	LDFLAGS="$LDFLAGS -n32"
	DEF_WANTHSREGEX=yes
	DBM_LIB=""
	if [ "$RULE_IRIXNIS" = "yes" ]; then
	    OS='SGI IRIX w/NIS'
	    CFLAGS="$CFLAGS -DIRIX"
	    LIBS="$LIBS -lsun"
	else
	    OS='SGI IRIX'
	    CFLAGS="$CFLAGS -DIRIX"
	fi
	;;
    *-sgi-irix32)
	DEF_WANTHSREGEX=yes
	DBM_LIB=""
	if [ "$RULE_IRIXN32" = "yes" ]; then
	    CFLAGS="$CFLAGS -n32"
	    LDFLAGS="$LDFLAGS -n32"
	    if [ "$RULE_IRIXNIS" = "yes" ]; then
		OS='SGI IRIX-32 w/NIS'
	    else
		OS='SGI IRIX-32'
	    fi
	else
	    if [ "$RULE_IRIXNIS" = "yes" ]; then
		OS='SGI IRIX w/NIS'
	    else
		OS='SGI IRIX'
	    fi
	fi
	CFLAGS="$CFLAGS -DIRIX"
	;;
    *-sgi-irix)
	DEF_WANTHSREGEX=yes
	DBM_LIB=""
	if [ "$RULE_IRIXNIS" = "yes" ]; then
	    OS='SGI IRIX w/NIS'
	    CFLAGS="$CFLAGS -DIRIX"
	    LIBS="$LIBS -lsun"
	else
	    OS='SGI IRIX'
	    CFLAGS="$CFLAGS -DIRIX"
	fi
	;;
    *-linux2)
	DEF_WANTHSREGEX=yes
	OS='Linux'
	CFLAGS="$CFLAGS -DLINUX=2"
	LIBS="$LIBS -lm"
	;;
    *-linux1)
	DEF_WANTHSREGEX=yes
	OS='Linux'
	CFLAGS="$CFLAGS -DLINUX=1"
	;;
    *-lynx-lynxos*)
	OS='LynxOS'
	CFLAGS="$CFLAGS -DLYNXOS"
	LIBS="$LIBS -lbsd -ldes -lc_p"
	;;
    *486-*-bsdi*)
	OS='BSDI w/486'
	CFLAGS="$CFLAGS -m486"
	DBM_LIB=""
	DB_LIB=""
	;;
    *-bsdi*)
	OS='BSDI'
	DBM_LIB=""
	DB_LIB=""
	;;
    *486-*-freebsd*|*486-*-netbsd*)
	OS='FreeBSD/NETBSD on 486'
	LIBS="$LIBS -lcrypt"
	DBM_LIB=""
	DB_LIB=""
	;;
    *-freebsd*|*-netbsd*)
	OS='FreeBSD/NetBSD'
	LIBS="$LIBS -lcrypt"
	DBM_LIB=""
	DB_LIB=""
	;;
    *-openbsd*)
	OS='OpenBSD'
	;;
    *-next-nextstep*)
	OS='NeXT'
	CFLAGS="$CFLAGS -DNEXT"
	DEF_WANTHSREGEX=yes
	RANLIB="sleep 5; /bin/ranlib"
	# ranlib on most NeXTs sets the time wrong. 5 secs wait does much good
	;;
    *-dec-osf*)
	OS='DEC OSF/1'
	CFLAGS="$CFLAGS -DOSF1"
	LIBS="$LIBS -lm"
	;;
    *-qnx)
	OS='QNX'
	CFLAGS="$CFLAGS -DQNX"
	LIBS="$LIBS -N128k -lsocket -lunix"
	DEF_WANTHSREGEX=yes
	;;
    *-qnx32)
	OS='QNX32'
	CFLAGS="$CFLAGS -DQNX -mf -3"
	LIBS="$LIBS -N128k -lsocket -lunix"
	DEF_WANTHSREGEX=yes
	;;
    *-isc4*)
	OS='ISC 4'
	CC='gcc'
	CFLAGS="$CFLAGS -posix -DISC"
	LDFLAGS="$LDFLAGS -posix"
	LIBS="$LIBS -linet"
	DEF_WANTHSREGEX=yes
	;;
    *-sco3*)
	OS='SCO 3'
	CFLAGS="$CFLAGS -DSCO -Oacgiltz"
	LIBS="$LIBS -lPW -lsocket -lmalloc -lcrypt_i"
	DEF_WANTHSREGEX=yes
	;;
    *-sco5*)
	OS='SCO 5'
	CFLAGS="$CFLAGS -DSCO5"
	LIBS="$LIBS -lsocket -lmalloc -lprot"
	DEF_WANTHSREGEX=no
	;;
    *-solaris2*)
    	SOLVER=`echo $PLAT | sed 's/^.*solaris2.//'`
	OS="Solaris $SOLVER"
	CFLAGS="$CFLAGS -DSOLARIS2=$SOLVER"
	LIBS="$LIBS -lsocket -lnsl"
	case "$SOLVER" in
	    2[56789]*)
	    	LIBS="$LIBS -lpthread"
		;;
	esac
	DBM_LIB=""
	case "$SOLVER" in
	    2[0123]*)
		DEF_WANTHSREGEX=yes
		;;
	    *)
		DEF_WANTHSREGEX=no
		;;
	esac
	;;
    *-sunos4*)
	OS='SunOS 4'
	CFLAGS="$CFLAGS -DSUNOS4 -DUSEBCOPY"
	DEF_WANTHSREGEX=yes
	;;
    *-unixware1)
	DEF_WANTHSREGEX=yes
	OS='Unixware'
	CFLAGS="$CFLAGS -DSVR4 -DNO_LINGCLOSE"
	LIBS="$LIBS -lsocket -lnsl -lcrypt"
	;;
    *-unixware2)
	DEF_WANTHSREGEX=yes
	OS='Unixware'
	CFLAGS="$CFLAGS -DSVR4 -DNO_LINGCLOSE"
	LIBS="$LIBS -lsocket -lnsl -lcrypt"
	;;
    *-unixware211)
	OS='Unixware 2.1.1'
	CFLAGS="$CFLAGS -DUW"
	LIBS="$LIBS -lsocket -lnsl -lcrypt"
	;;
    *-unixware212)
	OS='Unixware 2.1.2'
	CFLAGS="$CFLAGS -DUW"
	LIBS="$LIBS -lsocket -lnsl -lcrypt"
	DBM_LIB=""
	;;
    maxion-*-sysv4*)
    	OS='SVR4'
	CFLAGS="$CFLAGS -DSVR4"
	DEF_WANTHSREGEX=yes
	LIBS="$LIBS -lsocket -lnsl -lc -lgen"
	;;
    *-sni-sysv4*)
	OS='SVR4'
	CFLAGS="$CFLAGS -DSVR4 -D_XPG_IV -DHAVE_MMAP"
	DEF_WANTHSREGEX=yes
	LIBS="$LIBS -lsocket -lnsl -lc"
	;;
    DS/90\ 7000-*-sysv4*)
	OS='UXP/DS'
	CFLAGS="$CFLAGS -DUXPDS"
	LIBS="$LIBS -lsocket -lnsl"
	DEF_WANTHSREGEX=yes
	;;
    *-tandem-sysv4*)
	OS='SVR4'
	CFLAGS="$CFLAGS -DSVR4"
	LIBS="$LIBS -lsocket -lnsl"
	DEF_WANTHSREGEX=yes
	;;
    *-sysv4*)
	OS='SVR4'
	CFLAGS="$CFLAGS -DSVR4"
	LIBS="$LIBS -lsocket -lnsl -lc"
	;;
    88k-encore-sysv4)
	OS='Encore UMAX V'
	CFLAGS="$CFLAGS -DSVR4 -DENCORE"
	DEF_WANTHSREGEX=yes
	LIBS="$LIBS -lPW"
	;;
    *-uts*)
	OS='Amdahl UTS'
	CFLAGS="$CFLAGS -Xa -eft -DUTS21"
	LIBS="$LIBS -lsocket -lbsd -la"
	;;
    *-ultrix)
	OS='ULTRIX'
	CFLAGS="-DULTRIX"
	DEF_WANTHSREGEX=yes
	SHELL="/bin/sh5"
	;;
    *powerpc-tenon-machten*)
	OS='MachTen PPC'
	LDFLAGS="$LDFLAGS -Xlstack=0x14000 -Xldelcsect"
	;;
    *-machten*)
	OS='MachTen 68K'
	LDFLAGS="$LDFLAGS -stack 0x14000"
	DEF_WANTHSREGEX=yes
	;;
    *convex-v11*)
	OS='CONVEXOS11'
	CFLAGS="$CFLAGS -ext -DCONVEXOS11"
	OPTIM="-O1" # scalar optimization only
	CC='cc'
	DEF_WANTHSREGEX=yes
	;;
    i860-intel-osf1)
	DEF_WANTHSREGEX=yes
	OS='Paragon OSF/1'
	CFLAGS="$CFLAGS -DPARAGON"
	;;
    *DYNIX*)
	DEF_WANTHSREGEX=yes
	OS='SEQUENT'
	CFLAGS="$CFLAGS -DSEQUENT"
	;;
    *NEWS-OS*)
	DEF_WANTHSREGEX=yes
	OS='SONY NEWS-OS'
	CFLAGS="$CFLAGS -DNEWSOS"
	;;
    *-riscix)
	OS='Acorn RISCix'
	CFLAGS="$CFLAGS -DRISCIX"
	OPTIM="-O"
	MAKE="make"
	DEF_WANTHSREGEX=yes
	;;
    *-BeOS*)
	OS='BeOS';
	CFLAGS="$CFLAGS -DBEOS"
	DEF_WANTHSREGEX=yes
	;;
    *) # default: Catch systems we don't know about
    	echo Sorry, but we cannot grok \"$PLAT\"
	echo uname -m
	uname -m
	echo uname -r
	uname -r
	echo uname -s
	uname -s
	echo uname -v
	uname -v
	echo uname -X
	uname -X
	echo Ideally, read the file PORTING, do what it says, and send the
	echo resulting patches to The Apache Group by filling out a report
	echo form at http://www.apache.org/bugdb.cgi - or, if your browser
	echo isn\'t forms-capable, you can send them via email to 
	echo apache-bugs@apache.org.  If you don\'t wish to do the port
	echo yourself, please submit this output rather than the patches.
	echo Thank you
	exitcode=1
	exit 1
	;;
esac

#
# And adjust/override WANTHSREGEX as needed
#
if [ "$RULE_WANTHSREGEX" = "default" ]; then
	if [ "x$DEF_WANTHSREGEX" = "x" ]; then
		RULE_WANTHSREGEX=no
	else
		RULE_WANTHSREGEX=$DEF_WANTHSREGEX
	fi
fi

####################################################################
# Show user what OS we came up with
#
echo " + configured for $OS platform"

####################################################################
# And update Makefile.config with what we came up with
#
echo "###############" >> Makefile.config
echo "# Platform: $OS" >> Makefile.config
echo "# Final Rules:" >> Makefile.config
echo "#  Rule WANTHSREGEX=$RULE_WANTHSREGEX" >> Makefile.config
echo "###############" >> Makefile.config

####################################################################
# Now we determine the C-compiler and optimization level
# to use. Settings of CC and OPTIM in Configuration have
# the highest precedence; next comes any settings from
# the above "OS-specific" section. If still unset,
# then we look for a known compiler somewhere in PATH
#
#
# First, look for a CC=<whatever> setting in Configure (recall, we
# copied these to Makefile.config)
#
TCC=`egrep '^CC=' Makefile.config | tail -1 | awk -F= '{print $2}'`
if [ "x$TCC" = "x" ]; then
    if [ "x$CC" = "x" ]; then
    #
    # At this point, CC is not set in Configure or above, so we
    # try to find one
    #
	for compilers in "gcc" "cc" "acc" "c89"
	do
	    lookedfor="$lookedfor $compilers"
	    if ./helpers/PrintPath -s $compilers; then
		COMPILER="$compilers"
		break
	    fi
	done
	if [ "x$COMPILER" = "x" ]; then
	    echo "Error: could not find any of these C compilers"
	    echo " anywhere in your PATH: $lookedfor"
	    echo "Configure terminated"
	    exitcode=1
	    exit 1
	fi
	CC=$COMPILER
    fi
    echo " + setting C compiler to $CC"
fi

#
# Look for OPTIM and save for later
#
TOPTIM=`egrep '^OPTIM=' Makefile.config | tail -1 | awk -F= '{print $2}'`

####################################################################
# Set the value of CC if need be
#
if [ "x$TCC" = "x" ]; then
    echo "CC=$CC" >> Makefile.config
fi

####################################################################
# Now we do some OS specific adjustments... for some OSs, we need
# to adjust CFLAGS and/or OPTIM depending on which compiler we
# are going to use. This is easy, since this can be gleamed from
# Makefile.config
#
case "$OS" in
    'ULTRIX')
	if [ "$TCC" = "cc" ]; then
	    CFLAGS="$CFLAGS -std"
	fi
	;;
    'SCO 5')
	if [ "$TCC" = "cc" ]; then
	    OSBPRINTF="-K noinline"
	fi
	;;
    'HI-UX')
	if [ "$TCC" = "cc" ]; then
	    CFLAGS="$CFLAGS -Aa -D_HIUX_SOURCE"
	    OPTIM=" "
	    TOPTIM=""
	fi
	;;
    'HP-UX'|'HP-UX 10')
	if [ "$TCC" = "cc" ]; then
	    CFLAGS="$CFLAGS -Aa -D_HPUX_SOURCE"
	    OPTIM=" "
	    TOPTIM=""
	fi
	;;
esac

####################################################################
# OK, now we can write OPTIM
#
if [ "x$TOPTIM" = "x" ]; then
    echo "OPTIM=$OPTIM" >> Makefile.config
fi

####################################################################
# Now we do some general checks and some intelligent Configuration
# control.

#
# Use TestCompile to look for various LIBS
#
case "$PLAT" in
    *-linux*)
	# newer systems using glibc 2.x need -lcrypt
	if ./helpers/TestCompile lib crypt; then
	    LIBS="$LIBS -lcrypt"
	fi
	;;

    *-dg-dgux*)
	# R4.11MU02 requires -lsocket -lnsl ... no idea if it's earlier or
	# later than what we already knew about.  PR#732
	if ./helpers/TestCompile lib socket; then
	    LIBS="$LIBS -lsocket"
	fi
	if ./helpers/TestCompile lib nsl; then
	    LIBS="$LIBS -lnsl"
	fi
	;;
esac

#
# Now HS's POSIX regex implementation if needed/wanted
#
if [ "$RULE_WANTHSREGEX" = "yes" ]; then
    REGLIB="regex/libregex.a"
    SUBDIRS="$SUBDIRS regex"
    INCLUDES_AUTODEPTH="$INCLUDES_AUTODEPTH regex"
fi

#
# Now SOCKS4.
#  NOTE: We assume that if they are using SOCKS4, then they've
#   adjusted EXTRA_LIBS and/or EXTRA_LDFLAGS as required,
#   otherwise we assume "-L/usr/local/lib -lsocks"
#
if [ "$RULE_SOCKS4" = "yes" ]; then
    # Set flag and check Makefile for -lsocks line
    CFLAGS="$CFLAGS -Dconnect=Rconnect -Dselect=Rselect"
    CFLAGS="$CFLAGS -Dgethostbyname=Rgethostbyname"
    if grep "EXTRA_" Makefile | grep "\-lsocks" > /dev/null; then : ;
    else
	LIBS="$LIBS -L/usr/local/lib -lsocks"
    fi
    if [ "$OS" = "Solaris 2" ]; then
	LIBS="$LIBS -lresolv"
    fi
fi

####################################################################
# Find out what modules we want and try and configure things for them
# Module lines can look like this:
#
#  Module  name_module    some/path/mod_name[.[oa]]
#  AddModule              some/path/mod_name[.[oa]]
#
# In both cases, the some/path can either be an arbitrary path (including
# an absolue path), or a path like "modules/DIR", in which case we _might_
# auto-generate a Makefile in modules/DIR (see later).
#
# The first case is the original style, where we give the module's
# name as well as it's binary file location - either a .o or .a.
#
# The second format is new, and means we do not repeat the module
# name, which is already part of the module source or definition.
# The way we find the module name (and other optional information about
# the module) is like this:
#
#  1 If extension is not given or is .c, assume .o was given and goto 3
#  2 If extension if .module, go to D1
#  3 If extension is .o, look for a corresponding .c file and if
#      found, go to C1
#  4 If no .c file was found, look for a .module file (Apache module
#      definition file). If found, go to D1
#  5 Assume module name is the "name" part of "mod_name", as in
#      name_module.
#
# If a C file is found:
#
# C1 Look for module name given by an MODULE: line (e.g. MODULE: name_module)
#      If found assume module contains a definition, and go to D1
# C2 If not found, look for a module name given on the declaration of the
#      module structure (e.g. module name_module).
# C3 If neither given, go to 4 above.
#
# If a definition file is found, or a .c file includes a module definition:
#
# D1 Get the module name from the MODULE: name= line
# D2 Get other module options (libraries etc). To be done later.
#

# For now, we will convert the AddModule lines into Module format
# lines, so the rest of Configure can do its stuff without too much
# additional hackery. It would be nice to reduce the number of times
# we have to awk the $tmpfile, though.

# MODFILES contains a list of module filenames (could be .c, .o, .a
#    or .module files) from AddModule lines only
# MODDIRS contains a list of subdirectories under 'modules' which
#    contain modules we want to build from both AddModule and Module
#    lines

echo " + Adding selected modules"

MODFILES=`awk <$tmpfile '$1 == "AddModule" { printf "%s ", $2 }'`
MODDIRS=`awk < $tmpfile '
	($1 == "Module" && $3 ~ /^modules\//) {
	    split ($3, pp, "/")
	    if (! SEEN[pp[2]]) {
		printf "%s ", pp[2]
		SEEN[pp[2]] = 1
	    }
    	}
	($1 == "AddModule" && $2 ~ /^modules\//) { 
	    split ($2, pp, "/")
	    if (! SEEN[pp[2]]) {
		printf "%s ", pp[2]
		SEEN[pp[2]] = 1
	    } 
    	}'`

#
# Now autoconfigure each of the modules specified by AddModule.
# Use tmpfile2 for the module definition file, and tmpfile3 for the
# shell commands to be executed for this module.
#

for modfile in $MODFILES ; do
#	echo Trying to find $modfile
	rm -f $tmpfile2 $tmpfile3
	modname=''

	ext=`echo $modfile | sed 's/^.*\.//'`
	modbase=`echo $modfile | sed 's/\.[^.]*$//'`
	if [ x$ext = x$modfile ]; then ext=o; modbase=$modfile; modfile=$modbase.o; fi
	if [ x$ext = x ] ; then ext=o; modbase=$modfile; fi
	if [ x$ext = xc ] ; then ext=o; fi

	# modbase is the path+filename without extension, ext is the
	# extension given, or if none, o
#	echo bas=$modbase ext=$ext

	if [ -r $modbase.module ] ; then
		cat $modbase.module > $tmpfile2
	else
	    if [ -f $modbase.c ] ; then
		# Guess module structure name in case there is not
		# module definition in this file
		modname=`egrep '^module .*;' $modbase.c | head -1 |\
			sed 's/^module.*[ 	][ 	]*//' | \
			sed 's/[ 	]*;[ 	]*$//'`
		# Get any module definition part
		if grep "MODULE-DEFINITION-" $modbase.c > /dev/null; then
		cat $modbase.c | \
		sed '1,/MODULE-DEFINITION-START/d;/MODULE-DEFINITION-END/,$d' \
			> $tmpfile2
		fi
	    fi
	fi		
	if [ -r $tmpfile2 ] ; then
		# Read a module definition from .module or .c
		modname=`grep "Name:" $tmpfile2 | sed 's/^.*Name:[ 	]*//'`
		if grep "ConfigStart" $tmpfile2 > /dev/null \
		 && grep "ConfigEnd" $tmpfile2 > /dev/null; then
		    sed '1,/ConfigStart/d;/ConfigEnd/,$d' $tmpfile2 > \
		     $tmpfile3
		    echo "    o $modname uses ConfigStart/End:"
		    if [ "$RULE_PARANOID" = "yes" ]; then
			sed 's/^/>> /' $tmpfile3
		    fi
		    . ./$tmpfile3
		fi
		rm -f $tmpfile2 $tmpfile3
		ext=o
	fi
	if [ "x$modname" = "x" ] ; then
		modname=`echo $modbase | sed 's/^.*\///' | \
			sed 's/^mod_//' | sed 's/^lib//' | sed 's/$/_module/'`
	fi
#	echo "Adding Module $modname $modbase.$ext"
	echo "Module $modname $modbase.$ext" >>$tmpfile
done

# $tmpfile now contains Module lines for all the modules we want

# create modules.c

sed 's/_module//' $tmpfile | awk >modules.c '
    BEGIN {
	modules[n++] = "core"
	pmodules[pn++] = "core"
    } 
    /^Module/ { modules[n++] = $2 ; pmodules[pn++] = $2 } 
    /^%Module/ { pmodules[pn++] = $2 } 
    END {
	print "/* modules.c --- automatically generated by Apache"
	print " * configuration script.  DO NOT HAND EDIT!!!!!"
	print " */"
	print ""
	print "#include \"httpd.h\""
	print "#include \"http_config.h\""
	print ""
	for (i = 0; i < pn; ++i) {
	    printf ("extern module %s_module;\n", pmodules[i])
	}
	print ""
	print "module *prelinked_modules[] = {"
	for (i = 0; i < n; ++i) {
	    printf "  &%s_module,\n", modules[i]
	}
	print "  NULL"
	print "};"
	print "module *preloaded_modules[] = {"
	for (i = 0; i < pn; ++i) {
	    printf "  &%s_module,\n", pmodules[i]
	}
	print "  NULL"
	print "};"
    }'

# figure out which module dir require use to autocreate a Makefile.
# for these dirs we must not list the object files from the AddModule
# lines individually since the auto-generated Makefile will create
# a library called libMODDIR.a for it (MODDIR is the module dir
# name). We create two variable here:
#
#   AUTODIRS   Space separated list of module directories, relative to
#              src
#   AUTOLIBS   Space separated list of auto-generated library files

for moddir in $MODDIRS 
do
	if [ -f modules/$moddir/Makefile.tmpl ] ; then
		AUTODIRS="$AUTODIRS modules/$moddir"
		AUTOLIBS="$AUTOLIBS modules/$moddir/lib$moddir.a"
	fi
done

# Add the module targets to the Makefile. Do not add individual object
# targets for auto-generated directories.

cat > $awkfile <<EOF1
    BEGIN {
	split ("$AUTODIRS", tmp, " ")
EOF1
cat >> $awkfile <<'EOF2'
	for ( key in tmp ) {
	    autodirs[tmp[key]] = 1
	}
     }
    /^Module/ { modules[n++] = $3 }
    /^%Module/ { modules[n++] = $3 }
    END {
	print "MODULES= \\"
	for (i = 0; i < n; ++i) {
	    split (modules[i], pp, "/")
	    dir = pp[1] "/" pp[2] 
	    inthere = 0
	    for ( tdir in autodirs ) {
	        if (tdir == dir) 
		    inthere = 1
	    }
	    if (inthere == 1)
		continue
	    else
		printf ("  %s \\\n", modules[i])
	}
    }
EOF2
awk -f $awkfile >>Makefile <$tmpfile

# Now add the auto-generated library targets.  Need to use awk so we
# don't hang a continuation on the last line.

cat > $awkfile <<EOF3
    BEGIN {
	split ("$AUTOLIBS", libs)
EOF3
cat >> $awkfile <<'EOF4'
	z = 0
	for ( lib in libs ) {
	    if (z != 0)
		printf (" \\\n")
	    z++
	    printf ("  %s", libs[lib])
	}
    }
    END {
	printf ("\n")
    }
EOF4
awk -f $awkfile >>Makefile </dev/null

####################################################################
# Continue building Makefile.config.
#
echo  >> Makefile
echo "CFLAGS1=$CFLAGS">> Makefile.config
echo "INCLUDES1=$INCLUDES">> Makefile.config

INCLUDES_AUTODEPTH="$INCLUDES_AUTODEPTH $OSDIR main"
incprefix="-I"
for depth in 0 1 2; do
    incvar="INCLUDES_DEPTH${depth}="
    for i in $INCLUDES_AUTODEPTH; do
	incvar="$incvar${incprefix}$i "
    done
    echo "$incvar" >>Makefile.config
    incprefix="${incprefix}../"
done

echo "LIBS1=$LIBS">> Makefile.config
echo "LDFLAGS1=$LDFLAGS">> Makefile.config
echo "BROKEN_BPRINTF_FLAGS=$OSBPRINTF">> Makefile.config
echo "REGLIB=$REGLIB">> Makefile.config
echo "RANLIB=$RANLIB">> Makefile.config
echo "SHELL=$SHELL">> Makefile.config
echo "OSDIR=$OSDIR">> Makefile.config
echo "SUBDIRS=$SUBDIRS">> Makefile.config
echo >> Makefile.config
echo "#### End of Configure created section ####">> Makefile.config

####################################################################
# Use TestCompile to see if $(CC) is ANSI and as a "final" sanity
# check
#
echo " + doing sanity check on compiler and options"
if ./helpers/TestCompile sanity; then
    :
else
   echo "** A test compilation with your Makefile configuration"
   echo "** failed. This is most likely because your C compiler"
   echo "** is not ANSI. Apache requires an ANSI C Compiler, such"
   echo "** as gcc. The above error message from your compiler"
   echo "** will also provide a clue."
   echo " Aborting!"
   exitcode=1
   exit 1
fi

####################################################################
# Now (finish) creating the makefiles
#
# ./Makefile
#
cat Makefile.config >> Makefile
sed -e "s#@@Configuration@@#$file#" "Makefile.tmpl" >>Makefile

#
# directories to create makefiles in
#
MAKEDIRS="support main $OSDIR"
for dir in $MAKEDIRS ; do
	echo Creating Makefile in $dir
	cat Makefile.config $dir/Makefile.tmpl > $dir/Makefile
done

cat Makefile.config >modules/Makefile

cat << EOF >> modules/Makefile
MODULES=$MODDIRS
CFLAGS=\$(OPTIM) \$(CFLAGS1) \$(EXTRA_CFLAGS)

default: all

all clean :: 
	for i in \$(MODULES); do \\
	 (cd \$\$i; \\
	  \$(MAKE) CC='\$(CC)' AUX_CFLAGS='\$(CFLAGS)' RANLIB='\$(RANLIB)' \$@) || exit 1;\\
	done

EOF

for moddir in $AUTODIRS ; do
	echo "Creating Makefile in $moddir"

	cat Makefile.config > $moddir/Makefile
	cat << 'EOF' >> $moddir/Makefile
CFLAGS=$(OPTIM) $(CFLAGS1) $(EXTRA_CFLAGS)
LIBS=$(EXTRA_LIBS) $(LIBS1)
INCLUDES=$(INCLUDES1) $(INCLUDES_DEPTH2) $(EXTRA_INCLUDES)
LDFLAGS=$(LDFLAGS1) $(EXTRA_LDFLAGS)
INCDIR=../../main
EOF
	if [ -f $moddir/Makefile.libdir ]; then
	    # it's responsible for the rest of its Makefile
	    :
	else
	    basedir=`echo $moddir | sed 's/^[^/]*\///g'`
	    awk >> $moddir/Makefile < $tmpfile '
		BEGIN {
		    printf "OBJS="
		}
		($1 == "Module" && $3 ~ /^modules\/'$basedir'\//) { 
		    split ($3, pp, "/")
		    printf "%s ", pp[3] 
		} 
		END {
		    printf "\n"
		}'

	    echo "LIB=lib$basedir.a" >> $moddir/Makefile
	    cat << 'EOF' >> $moddir/Makefile

all:	$(LIB)

$(LIB): $(OBJS)
	rm -f $@
	ar cr $@ $(OBJS)
	$(RANLIB) $@

.c.o:
	$(CC) -c $(INCLUDES) $(CFLAGS) $(SPACER) $<

clean:
	rm -f *.o $(LIB)

$(OBJS): Makefile
EOF
	fi

    cat >> $moddir/Makefile < $moddir/Makefile.tmpl

done
